home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / terms / kermit / c / arcpro.w < prev    next >
Encoding:
Text File  |  1993-05-01  |  9.6 KB  |  265 lines
  1. char *protv = "C-Kermit Protocol Module 4C(029), 11 Jul 85"; /* -*-C-*- */
  2.  
  3. /* C K C P R O  -- C-Kermit Protocol Module, in Wart preprocessor notation. */
  4. /*
  5.  Authors: Frank da Cruz (SY.FDC@CU20B), Bill Catchings, Jeff Damens;
  6.  Columbia University Center for Computing Activities, January 1985.
  7.  Copyright (C) 1985, Trustees of Columbia University in the City of New York.
  8.  Permission is granted to any individual or institution to use, copy, or
  9.  redistribute this software so long as it is not sold for profit, provided this
  10.  copyright notice is retained. 
  11. */
  12. #include "ckcdeb.h"
  13. #include "ckcker.h"
  14. /*
  15.  Note -- This file may also be preprocessed by the Unix Lex program, but 
  16.  you must indent the above #include statements before using Lex, and then
  17.  restore them to the left margin in the resulting C program before compilation.
  18.  Also, the invocation of the "wart()" function below must be replaced by an
  19.  invocation  of the "yylex()" function.  It might also be necessary to remove
  20.  comments in the %%...%% section.
  21. */
  22.  
  23. /* State definitions for Wart (or Lex) */
  24. %states ipkt rfile rdata ssinit ssfile ssdata sseof sseot
  25. %states serve generic get rgen
  26.  
  27. /* External C-Kermit variable declarations */
  28.   extern char sstate, *versio, *srvtxt, *cmarg, *cmarg2;
  29.   extern char data[], filnam[], srvcmd[], ttname[], *srvptr;
  30.   extern int pktnum, timint, nfils, image, hcflg, xflg, speed, flow, mdmtyp;
  31.   extern int prvpkt, cxseen, czseen, server, local, displa, bctu, bctr, quiet;
  32.   extern int tsecs;
  33.   extern int putsrv(), puttrm(), putfil(), errpkt();
  34.   extern char *DIRCMD, *DELCMD, *TYPCMD, *SPACMD, *SPACM2, *WHOCMD;
  35.  
  36. /* Local variables */
  37.   static char vstate = 0;       /* Saved State   */
  38.   static char vcmd = 0;         /* Saved Command */
  39.   int x;                /* General-purpose integer */
  40.   char *s;              /* General-purpose string pointer */
  41.  
  42. /* Macros - Note, BEGIN is predefined by Wart (and Lex) */
  43. #define SERVE  tinit(); BEGIN serve
  44. #define RESUME if (server) { SERVE; } else return
  45.  
  46. %%
  47. /* Protocol entry points, one for each start state (sstate) */
  48.  
  49. s { tinit();                            /* Do Send command */
  50.     if (sinit()) BEGIN ssinit;
  51.        else RESUME; }
  52.  
  53. v { tinit(); sleep(1); nack(); BEGIN get; }                       /* Receive */
  54. r { tinit(); vstate = get;  vcmd = 0;   sipkt('I'); BEGIN ipkt; } /* Get */
  55. c { tinit(); vstate = rgen; vcmd = 'C'; sipkt('I'); BEGIN ipkt; } /* Host */
  56. g { tinit(); vstate = rgen; vcmd = 'G'; sipkt('I'); BEGIN ipkt; } /* Generic */
  57.  
  58. x { sleep(10); SERVE; }                 /* Be a Server */
  59.  
  60. a { errpkt("User cancelled transaction"); /* "Abort" -- Tell other side. */
  61.     x = quiet; quiet = 1;       /* Close files silently. */
  62.     clsif(); clsof(1); 
  63.     quiet = x; return(0); }     /* Return from protocol. */
  64.  
  65. /* Dynamic states: <current-states>input-character { action } */
  66.  
  67. <rgen,get,serve>S { rinit(data); bctu = bctr; /* Get Send-Init */
  68.            rtimer(); BEGIN rfile; }
  69.  
  70. <ipkt>Y  { spar(data);          /* Get ack for I-packet */
  71.            if (vcmd) { scmd(vcmd,cmarg); vcmd = 0; }
  72.            if (vstate == get) srinit();
  73.        BEGIN vstate; }
  74.  
  75. <ipkt>E  { if (vcmd) scmd(vcmd,cmarg);  /* Get E for I-packet (ignore) */
  76.            vcmd = 0; if (vstate == get) srinit();
  77.        BEGIN vstate; }
  78.  
  79. <serve>R { srvptr = srvcmd; decode(data,putsrv); /* Get Receive-Init */
  80.        cmarg = srvcmd;  nfils = -1;
  81.            if (sinit()) BEGIN ssinit; else { SERVE; } }
  82.  
  83. <serve>I { spar(data); rpar(data); ack1(data);   /* Get Init Parameters */
  84.        pktnum = 0; prvpkt = -1; }
  85.  
  86. <serve>G { srvptr = srvcmd; decode(data,putsrv); /* Get & decode command. */
  87.        putsrv('\0'); putsrv('\0');
  88.        sstate = srvcmd[0]; BEGIN generic; }
  89.  
  90. <serve>C { srvptr = srvcmd;              /* Get command for shell */
  91.        decode(data,putsrv); putsrv('\0');
  92.        if (syscmd(srvcmd,"")) BEGIN ssinit;
  93.        else { errpkt("Can't do system command"); SERVE; } }
  94.  
  95. <serve>. { errpkt("Unimplemented server function"); SERVE; } /* Other */
  96.  
  97. <generic>C { if (!cwd(srvcmd+1)) errpkt("Can't change directory"); /* CWD */
  98.              SERVE; }
  99.  
  100. <generic>D { if (syscmd(DIRCMD,srvcmd+2)) BEGIN ssinit; /* Directory */
  101.              else { errpkt("Can't list directory"); SERVE; } }
  102.  
  103. <generic>E { if (syscmd(DELCMD,srvcmd+2)) BEGIN ssinit; /* Erase */
  104.              else { errpkt("Can't remove file"); SERVE; } }
  105.  
  106. <generic>F { ack(); screen(SCR_TC,0,0l,""); return(0); } /* Finish and Bye */
  107. <generic>L { ack(); ttres(); screen(SCR_TC,0,0l,""); return(zkself()); }
  108.  
  109. <generic>H { if (sndhlp()) BEGIN ssinit;
  110.              else { errpkt("Can't send help"); SERVE; } }
  111.  
  112. <generic>T { if (syscmd(TYPCMD,srvcmd+2)) BEGIN ssinit;
  113.              else { errpkt("Can't type file"); SERVE; } }
  114.  
  115. <generic>U { x = *(srvcmd+1);           /* Disk Usage query */
  116.              x = ((x == '\0') || (x == unchar(0)));
  117.          x = (x ? syscmd(SPACMD,"") : syscmd(SPACM2,srvcmd+2));
  118.              if (x) BEGIN ssinit; else { errpkt("Can't check space"); SERVE; }}
  119.  
  120. <generic>W { if (syscmd(WHOCMD,srvcmd+2)) BEGIN ssinit;
  121.              else { errpkt("Can't do who command"); SERVE; } }
  122.  
  123. <generic>. { errpkt("Unimplemented generic server function"); SERVE; }
  124.  
  125. /* Dynamic states, cont'd */
  126.  
  127.  
  128. <rgen>Y { decode(data,puttrm); RESUME; }    /* Got reply in ACK data */
  129.  
  130. <rgen,rfile>F { if (rcvfil()) { ack1(""); BEGIN rdata; } /* File header */
  131.         else { errpkt("Can't open file"); RESUME; } }
  132.  
  133. <rgen,rfile>X { opent(); ack(); BEGIN rdata; }  /* Screen data is coming */
  134.  
  135. <rfile>B { ack(); tsecs = gtimer(); reot(); RESUME; } /* Got EOT */
  136.  
  137. <rdata>D { if (cxseen) ack1("X");   /* Got data. */
  138.                else if (czseen) ack1("Z");
  139.            else ack();
  140.        decode(data,putfil); }
  141.  
  142. <rdata>Z  { if (reof() < 0) {           /* Got End Of File */
  143.               errpkt("Can't close file"); RESUME;
  144.             } else { ack(); BEGIN rfile; } }
  145.  
  146. <ssinit>Y { spar(data); bctu = bctr;    /* Got ACK to Send-Init */
  147.             x = sfile(xflg);        /* Send X or F header packet */
  148.         if (x) { rtimer(); BEGIN ssfile; }
  149.         else { s = xflg ? "Can't execute command" : "Can't open file";
  150.             errpkt(s); RESUME; }
  151.           }
  152.  
  153. <ssfile>Y { srvptr = srvcmd;                 /* Got ACK to F */
  154.         decode(data,putsrv); putsrv('\0');
  155.         if (*srvcmd) tlog(F110," stored as",srvcmd,0);
  156.         if (sdata() < 0) { clsif(); seof(""); BEGIN sseof; }
  157.                 else BEGIN ssdata; }
  158.  
  159. <ssdata>Y { if (canned(data)) { clsif(); seof("D"); BEGIN sseof; }
  160.             else if (sdata() < 0) { clsif(); seof(""); BEGIN sseof; } }
  161.  
  162. <sseof>Y  { if (gnfile() > 0) {     /* Got ACK to EOF, get next file */
  163.         if (sfile(xflg)) BEGIN ssdata;
  164.         else { errpkt("Can't open file") ; RESUME; }
  165.         } else {            /* If no next file, EOT */
  166.         tsecs = gtimer();
  167.         seot();
  168.         BEGIN sseot; }
  169.       }
  170.  
  171. <sseot>Y { RESUME; }            /* Got ACK to EOT */
  172.  
  173. E { ermsg(data);            /* Error packet, issue message. */
  174.     x = quiet; quiet = 1;       /* Close files silently, */
  175.     clsif(); clsof(1);          /* discarding any output file. */
  176.     tsecs = gtimer();
  177.     quiet = x; RESUME; }
  178.  
  179. . { errpkt("Unknown packet type"); RESUME; } /* Anything else, send error */
  180. %%
  181.  
  182. int tbl(idx)
  183. int idx;
  184. { int l, u, m, ml, mr;
  185.   /**********************************************************************/
  186.   /* tbl() simulates a (sparse) 1-D array, run-length encoded into jidx */
  187.   /* and jtbl. The assertion is:                                        */
  188.   /*              for all m, idx s.t. jdx[m] <= idx < jdx[m+1],         */
  189.   /*              tbl[idx] == tbl[jdx[m]] == jtbl[m]                    */
  190.   /* Here we (binary) search for an m s.t. jdx[m] <= idx < jdx[m+1],    */
  191.   /* returning jtbl[m] (== tbl[idx], as required.                       */
  192.   /**********************************************************************/
  193.   l = 0;  u = jdxupb;
  194.   while (l <= u) {
  195.     ml = jdx[m = (l + u) >> 1];  mr = jdx[m+1];
  196.     if ((ml <= idx) && (idx < mr)) return (jtbl[m]);
  197.     if (ml > idx) u = m;
  198.     else if (idx >= mr) l = m;
  199.   }
  200. }
  201.  
  202. /*  P R O T O  --  Protocol entry function  */
  203.  
  204. proto() {
  205.  
  206.     extern int sigint();
  207.     int x;
  208.  
  209.     conint(sigint);         /* Enable console interrupts */
  210.  
  211. /* Set up the communication line for file transfer. */
  212.  
  213.     if (local && (speed < 0)) {
  214.     screen(SCR_EM,0,0l,"Sorry, you must 'set speed' first");
  215.     return;
  216.     }
  217.  
  218.     x = -1;
  219.     if (ttopen(ttname,&x,mdmtyp) < 0) {
  220.     debug(F111,"proto ttopen local",ttname,local);
  221.     screen(SCR_EM,0,0l,"Can't open line");
  222.     return;
  223.     }
  224.     if (x > -1) local = x;
  225.     debug(F111,"proto ttopen local",ttname,local);
  226.  
  227.     x = (local) ? speed : -1;
  228.     if (ttpkt(x,flow) < 0) {        /* Put line in packet mode, */
  229.     screen(SCR_EM,0,0l,"Can't condition line");
  230.     return;
  231.     }
  232.     if (sstate == 'x') {        /* If entering server mode, */
  233.     server = 1;         /* set flag, */
  234.     if (!quiet) {
  235.         if (!local)         /* and issue appropriate message. */
  236.             conol(srvtxt);
  237.         else {
  238.             conol("Entering server mode on ");
  239.         conoll(ttname);
  240.         }
  241.     }
  242.     } else server = 0;
  243.     sleep(1);
  244.  
  245. /*
  246.  The 'wart()' function is generated by the wart program.  It gets a
  247.  character from the input() routine and then based on that character and
  248.  the current state, selects the appropriate action, according to the state
  249.  table above, which is transformed by the wart program into a big case
  250.  statement.  The function is active for one transaction.
  251. */
  252.  
  253.     wart();             /* Enter the state table switcher. */
  254.     
  255.     if (server) {           /* Back from packet protocol. */
  256.     server = 0;
  257.         if (!quiet)             /* Give appropriate message */
  258.         conoll("C-Kermit server done");
  259.     }
  260.  
  261.     ttclos();
  262.  
  263.     screen(SCR_TC,0,0l,"");     /* Transaction complete */
  264. }
  265.